/*
 * File:   accueil.cpp
 * Author: Nicolas Proust & Pierre-Antoine Jahan
 *
 * Created on 29 janvier 2013, 14:03
 */

#include "modele/Task.h"
#include <qt4/QtCore/qobject.h>
#include "accueil.h"
#include "modele/ListOfTask.h"
#include "modele/User.h"
#include "vue/addListDialog.h"
#include "addTaskDialog.h"
#include "addTaskTempDialog.h"
#include "addTemplateDialog.h"
#include "QMessageBox"
#include "list"
#include <QtXml>
#include <iostream>
#include <vector>
#include <string>
#include <stdlib.h>
#include <sstream>
#include <algorithm>
#include <qt4/QtGui/qevent.h>

using namespace std;

User utilisateur;

accueil::accueil() {
    widget.setupUi(this);

    widget.listeTachesAFaire->setColumnWidth(0,130);
    widget.listeTachesAFaire->setColumnWidth(1,64);
    widget.listeTachesAFaire->setColumnWidth(2,130);
    widget.listeTachesAFaire->setColumnWidth(3,64);
    
    widget.listeTachesAFaire_2->setColumnWidth(0,201);
    widget.listeTachesAFaire_2->setColumnWidth(1,50);
    widget.listeTachesAFaire_2->setColumnWidth(2,119);
    
    //lecture du fichier listes.xml
    QDomDocument dom;
    QFile doc_xml("listes.xml");
    if(!doc_xml.open(QIODevice::ReadOnly))
    {
        QMessageBox::critical(this,"Erreur","Impossible d'ouvrir le ficher XML");
        doc_xml.close();
        return;
    }
    if(!dom.setContent(&doc_xml))
    {
        QMessageBox::critical(this,"Erreur","Impossible d'ouvrir le ficher XML");
        doc_xml.close();
        return;
    }
    doc_xml.close();
    
    //lecture du fichier templates.xml
    QDomDocument dom2;
    QFile doc_xml2("templates.xml");
    if(!doc_xml2.open(QIODevice::ReadOnly))
    {
        QMessageBox::critical(this,"Erreur","Impossible d'ouvrir le ficher XML");
        doc_xml2.close();
        return;
    }
    if(!dom2.setContent(&doc_xml2))
    {
        QMessageBox::critical(this,"Erreur","Impossible d'ouvrir le ficher XML");
        doc_xml2.close();
        return;
    }
    doc_xml2.close();
    
    //creation des objets sauvegardé
    readDom();
    
    //Effacement des taches au lancement car aucune liste séléctionnée
    int nbTasks = widget.listeTachesAFaire->topLevelItemCount();
    for (int i=0; i<nbTasks;++i)
    {     
        QTreeWidgetItem *tmpItem = widget.listeTachesAFaire->takeTopLevelItem(0);
        delete tmpItem;
    }
    
    widget.boutonModifierListe->setDisabled(true);
    widget.boutonSupprimerListe->setDisabled(true);
    widget.boutonSupprimerTache->setDisabled(true);
    widget.boutonCreerTache->setDisabled(true);
    widget.boutonModifierTache->setDisabled(true);
    
    widget.boutonModifierListe_2->setDisabled(true);
    widget.boutonSupprimerListe_2->setDisabled(true);
    widget.boutonSupprimerTache_2->setDisabled(true);
    widget.boutonCreerTache_2->setDisabled(true);
    widget.boutonModifierTache_2->setDisabled(true);
    widget.boutonUtiliser->setDisabled(true);
    

    //Signaux onglet Liste
    QObject::connect(widget.boutonCreerListe, SIGNAL(clicked()), this, SLOT(addListListener()));
    QObject::connect(widget.boutonCreerTache, SIGNAL(clicked()), this, SLOT(addTaskListener()));
    QObject::connect(widget.boutonSupprimerListe, SIGNAL(clicked()), this, SLOT(removeList()));
    QObject::connect(widget.boutonModifierListe, SIGNAL(clicked()), this, SLOT(modifyListListener()));
    QObject::connect(widget.listeListeTachesAFaire, SIGNAL(itemSelectionChanged()), this, SLOT(afficherTasksListener()));
    QObject::connect(widget.boutonSupprimerTache, SIGNAL(clicked()), this, SLOT(removeTask()));
    QObject::connect(widget.boutonModifierTache, SIGNAL(clicked()), this, SLOT(modifyTaskListener()));
    QObject::connect(widget.listeListeTachesAFaire, SIGNAL(itemSelectionChanged()), this, SLOT(buttonsListListener()));
    QObject::connect(widget.listeTachesAFaire, SIGNAL(itemSelectionChanged()), this, SLOT(buttonsTaskListener()));
    QObject::connect(widget.calendrier, SIGNAL(selectionChanged()), this, SLOT(listListTacheListener()));
    QObject::connect(widget.listeTachesAFaire, SIGNAL(itemSelectionChanged()), this, SLOT(addTaskButtonListener()));
    QObject::connect(widget.pushButtonListes, SIGNAL(clicked()), this, SLOT(afficherListesListener()));
    QObject::connect(widget.listeListeTachesAFaire, SIGNAL(itemClicked(QTableWidgetItem *)), this, SLOT(listeTacheAFaireListener()));
    
    
    //Signaux onglet Template
    QObject::connect(widget.boutonCreerListe_2, SIGNAL(clicked()), this, SLOT(addTemplateListener()));
    QObject::connect(widget.boutonModifierListe_2, SIGNAL(clicked()), this, SLOT(modifyTemplateListener()));
    QObject::connect(widget.boutonSupprimerListe_2, SIGNAL(clicked()), this, SLOT(removeTemplate()));
    QObject::connect(widget.boutonCreerTache_2, SIGNAL(clicked()), this, SLOT(addTaskTempListener()));
    QObject::connect(widget.boutonSupprimerTache_2, SIGNAL(clicked()), this, SLOT(removeTaskTemp()));
    QObject::connect(widget.listeListeTachesAFaire_2, SIGNAL(itemSelectionChanged()), this, SLOT(afficherTasksTempListener()));
    QObject::connect(widget.boutonModifierTache_2, SIGNAL(clicked()), this, SLOT(modifyTaskTempListener()));
    QObject::connect(widget.listeListeTachesAFaire_2, SIGNAL(itemSelectionChanged()), this, SLOT(buttonsTemplateListener()));
    QObject::connect(widget.listeTachesAFaire_2, SIGNAL(itemSelectionChanged()), this, SLOT(buttonsTaskTempListener()));
    QObject::connect(widget.listeTachesAFaire_2, SIGNAL(itemSelectionChanged()), this, SLOT(addTaskTempButtonListener()));
    QObject::connect(widget.boutonUtiliser, SIGNAL(clicked()), this, SLOT(utiliserTemplate()));
    QObject::connect(widget.listeListeTachesAFaire_2, SIGNAL(itemClicked(QTableWidgetItem *)), this, SLOT(tempTacheAFaireListener()));
    
    

}

accueil::~accueil() {
    clearDom();
    writeDom();
}

/**********************************************************************************************************************/
/*********                                          Onglet Liste                                               ********/
/**********************************************************************************************************************/

void accueil::addListListener() {
    addListDialog *addListList = new addListDialog(this, widget.calendrier->selectedDate(), utilisateur);
    addListList->setVisible(true);
}

void accueil::addTaskListener() {
    int rowSelected = widget.listeListeTachesAFaire->currentRow();
    QTableWidgetItem* itemNom = widget.listeListeTachesAFaire->item(rowSelected,0);
    string nomList(itemNom->text().toStdString());

    std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksLists();
    std::list<ListOfTask*>::iterator it = listListTask.begin();
    std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
    for(;it!=itEnd;++it) {
        ListOfTask* gr = *it;
        if(gr->getName()==nomList) {
            addTaskDialog *addTask = new addTaskDialog(this, gr->getDate());
            addTask->setVisible(true);
            break;
        }
    }
    
    
}

void accueil::addList(string name,Date date, ListOfTask* temp) {

    widget.centralwidget->setEnabled(true);
    ListOfTask *tmpListTasks = new ListOfTask(name,date);

    utilisateur.addList(tmpListTasks);
    
    if (temp!=NULL) {
        list<Task*> listOftasks = temp->getTasks();

        for (std::list<Task*>::iterator it = listOftasks.begin(); it != listOftasks.end(); ++it) {
            Task *tmpTask = *it;
            tmpTask->setChecked(false);
            list<Task*> listOfSstasks = tmpTask->getTasks();
            for (std::list<Task*>::iterator it2 = listOfSstasks.begin(); it2 != listOfSstasks.end(); ++it2) {
                Task *tmpSsTask = *it2;
                tmpSsTask->setChecked(false);
            }
            tmpListTasks->addTask(tmpTask);
        }
    }
    
    int currentLigne = widget.listeListeTachesAFaire->rowCount();

    //On ajoute une ligne au tableau
    widget.listeListeTachesAFaire->setRowCount(currentLigne+1);

    //On crÃ©er les diffÃ©rents items que l'on va ajouter au tableau
    QTableWidgetItem* itemName = new QTableWidgetItem;
    itemName->setText(QString(name.c_str()));

    QTableWidgetItem* itemDate = new QTableWidgetItem;
    itemDate->setText(QString(tmpListTasks->getDate().getDate().c_str()));

    //On ajoute les donnÃ©es au tableau
    widget.listeListeTachesAFaire->setItem(currentLigne, 0, itemName);
    widget.listeListeTachesAFaire->setItem(currentLigne, 1, itemDate);
}

void accueil::modifyList(string name, Date date) {
    
    std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksLists();
        
    std::list<ListOfTask*>::iterator it = listListTask.begin();
    std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
    for(;it!=itEnd;++it) {
        ListOfTask* gr = *it;
        cout << "modification de liste :" << endl;
        cout << gr->getName() << endl;
        cout << gr->getDate() << endl;
    } 

    int rowSelected = widget.listeListeTachesAFaire->currentRow();

    //On ajoute une ligne au tableau
    QTableWidgetItem* itemName = new QTableWidgetItem;
    itemName->setText(QString(name.c_str()));
    
    QTableWidgetItem* itemDate = new QTableWidgetItem;
    itemDate->setText(QString(date.getDate().c_str()));
    
    //On ajoute les donnÃ©es au tableau
    widget.listeListeTachesAFaire->setItem(rowSelected, 0, itemName);
    widget.listeListeTachesAFaire->setItem(rowSelected, 1, itemDate);

    //widget.listeListeTachesAFaire->resizeColumnsToContents();
}

void accueil::modifyListListener(){
    
    ListOfTask* list = NULL;
    int rowSelected = widget.listeListeTachesAFaire->currentRow();
    if(rowSelected==-1) {
        QMessageBox::information(this,"Erreur","Aucune liste selectionnee !",0,0,0);
    } else {
        QTableWidgetItem* itemNom = widget.listeListeTachesAFaire->item(rowSelected,0);
        string nomList(itemNom->text().toStdString());
        
        std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksLists();
        
        std::list<ListOfTask*>::iterator it = listListTask.begin();
        std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
        for(;it!=itEnd;++it) {
            ListOfTask* gr = *it;
            if(gr->getName()==nomList) {
                list = gr;
                break;
            }
        }  
        addListDialog *addListList = new addListDialog(this,list,utilisateur);
        addListList->setVisible(true);
     }
}

void accueil::removeList() {
    //recuperation de la ligne selectionnÃ©e
    int rowSelected = widget.listeListeTachesAFaire->currentRow();
    
    if(rowSelected==-1) {
        QMessageBox::information(this,"Erreur","Aucune liste selectionnee !",0,0,0);
    }
    else { 
        QTableWidgetItem* itemNom = widget.listeListeTachesAFaire->item(rowSelected,0);

        string nomList(itemNom->text().toStdString());
        std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksLists();
        std::list<ListOfTask*>::iterator it = listListTask.begin();
        std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
        
        switch( QMessageBox::information(this, "Attention", "Etes vous sur de vouloir supprimer la liste ainsi que l'integralite de son contenu ?", 
                QMessageBox::Yes | 
                QMessageBox::No) )
        {
          case QMessageBox::Yes:
            for(;it!=itEnd;++it) {
                ListOfTask* gr = *it;
                if(gr->getName()==nomList) {
                    utilisateur.removeList(gr);
                    break;
                }
            }
            widget.listeListeTachesAFaire->removeRow(rowSelected);
            break;
          case QMessageBox::No:
            qDebug( "no" );
            break;
          default:
            qDebug( "close" );
            break;
        } 
    }
}

//Ajout d'une tache
void accueil::addTask(string title, bool isOrdo, int num, bool ech, bool fixe, Date d, int relat) {
    
    //recuperation du no de la liste selectionne
    int listSelected = widget.listeListeTachesAFaire->currentRow();
    
    if(listSelected==-1) {
        QMessageBox::information(this,"Erreur","Aucune liste selectionnee !",0,0,0);
        return;
    }
    else { 
        Task *newTask = new Task(title, isOrdo, num, ech, fixe, d, relat);
        newTask->setChecked(false);
        
        QTreeWidgetItem *selectedtask = widget.listeTachesAFaire->currentItem();
        QTableWidgetItem* itemNom = widget.listeListeTachesAFaire->item(listSelected,0);
        string nomList(itemNom->text().toStdString());
        
        //ajout d'une tache principale
        if (selectedtask==NULL) {

            std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksLists();
            std::list<ListOfTask*>::iterator it = listListTask.begin();
            std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
            for(;it!=itEnd;++it) {
                ListOfTask* gr = *it;
                if(gr->getName()==nomList) {
                    gr->addTask(newTask);
                    break;
                }
            }  
            
            string name = newTask->getTitre(); 
            std::ostringstream oss;
            oss << newTask->getNumber();
            string num = oss.str();
            string date = newTask->getDate().getDate();
            string relat = afficheDateRelative(newTask->getRelative());

            QTreeWidgetItem *item = new QTreeWidgetItem;
             if (newTask->getNumber()==0) {
            item->setText(1,"");
            } else {
                item->setText(1,QString(num.c_str()));
            }
            item->setText(0,QString(name.c_str()));
            if (newTask->getDate().getDay()==0 && newTask->getRelative()==-1) {
                    item->setText(2,"");
            } else if(newTask->getRelative()!=-1) {
                item->setText(2,QString(relat.c_str()));
            } else if(newTask->getDate().getDay()!=0) {
                item->setText(2,QString(date.c_str()));
            }  
            item->setCheckState(3,Qt::Unchecked);

            widget.listeTachesAFaire->addTopLevelItem(item);
            widget.listeTachesAFaire->resizeColumnToContents(0);
            
        //ajout d'une sous tache
        } else {
            ListOfTask *currentListOfTask = NULL;
            std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksLists();
            std::list<ListOfTask*>::iterator it = listListTask.begin();
            std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
            for(;it!=itEnd;++it) {
                ListOfTask* gr = *it;
                if(gr->getName()==nomList) {
                    currentListOfTask = gr;
                    break;
                }
            } 
    
            list<Task*> top = currentListOfTask->getTasks();

            //On recupere la tache parent :
            Task* parentTask = recTaskFinder(top,selectedtask->text(0).toStdString());

            parentTask->addTask(newTask);
            
            string name = newTask->getTitre(); 
            std::ostringstream oss;
            oss << newTask->getNumber();
            string num = oss.str();
            string date = newTask->getDate().getDate();
            string relative = afficheDateRelative(newTask->getRelative());

            QTreeWidgetItem *item2 = new QTreeWidgetItem;
            if (newTask->getNumber()==0) {
            item2->setText(1,"");
            } else {
                item2->setText(1,QString(num.c_str()));
            }
            item2->setText(0,QString(name.c_str()));
            if (newTask->getDate().getDay()==0 && newTask->getRelative()==-1) {
                item2->setText(2,"");
            } else if(newTask->getRelative()!=-1) {
                item2->setText(2,QString(relative.c_str()));
            } else if(newTask->getDate().getDay()!=0) {
                item2->setText(2,QString(date.c_str()));
            }
            item2->setCheckState(3,Qt::Unchecked);
            
            selectedtask->addChild(item2);
            selectedtask->setExpanded(true);
            widget.listeTachesAFaire->resizeColumnToContents(0);
        }
    }
}

Task* accueil::recTaskFinder(list<Task*> top, string name) {
    
    for (std::list<Task*>::iterator it = top.begin(); it != top.end(); ++it) {
        Task *tmpTask = *it;
        //cout << tmpTask->getTitre() << "/" << name << endl;
        if(tmpTask->getTitre()==name) {
            cout<<"Find : " << tmpTask->getTitre()<<endl;
            return tmpTask;          
        }
        else {
           Task* retTask = recTaskFinder(tmpTask->getTasks(),name);
           if(retTask!=NULL) {
               return retTask;
           }
        }
    }
    return NULL;
}

void accueil::removeTask() {
   
    int rowSelectedList = widget.listeListeTachesAFaire->currentRow();
    QTreeWidgetItem *selectedtask = widget.listeTachesAFaire->currentItem();
    
    if(rowSelectedList==-1) {
       // QMessageBox::information(this,"Erreur","Aucune liste selectionnee !",0,0,0);
    }
    else{
        Task* task;
        
        if(selectedtask==NULL) {
            QMessageBox::information(this,"Erreur","Aucune tache selectionnee !",0,0,0);
        }
        else{   
            QTableWidgetItem* itemNomListe = widget.listeListeTachesAFaire->item(rowSelectedList,0);

            string nomList(itemNomListe->text().toStdString());
            string nomTache(selectedtask->text(0).toStdString());

            ListOfTask *currentListOfTask = NULL;
            std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksLists();
            std::list<ListOfTask*>::iterator it = listListTask.begin();
            std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
            for(;it!=itEnd;++it) {
                ListOfTask* gr = *it;
                if(gr->getName()==nomList) {
                    currentListOfTask = gr;
                    break;
                }
            }
            list<Task*> top = currentListOfTask->getTasks();
            task = recTaskFinder(top,nomTache);
            QTreeWidgetItem *parent = selectedtask->parent();
            if (parent==NULL) {
                currentListOfTask->removeTask(task);
               delete selectedtask;
            } else {
                Task *parentTask = recTaskFinder(top,parent->text(0).toStdString());
                parentTask->removeTask(task);
                parent->removeChild(selectedtask);
            }
        }
    }
    widget.listeTachesAFaire->resizeColumnToContents(0);
}

void accueil::modifyTask(string title, int num, Date d, int relat) {
   
    QTreeWidgetItem *selectedtask = widget.listeTachesAFaire->currentItem();

    if(num!=0) {
        std::ostringstream oss;
        oss << num;
        string number = oss.str();
        selectedtask->setText(1,QString(number.c_str()));
    } else {
        selectedtask->setText(1,"");
    }
    selectedtask->setText(0,QString(title.c_str()));
    if (d.getDay()==0 && relat==-1) {
        selectedtask->setText(2,"");
    } else if(relat!=-1) {
        string relative = afficheDateRelative(relat);
        selectedtask->setText(2,QString(relative.c_str()));
    } else if(d.getDay()!=0) {
        string date = d.getDate();
        selectedtask->setText(2,QString(date.c_str()));
    }
    widget.listeTachesAFaire->resizeColumnToContents(0);
}

void accueil::modifyTaskListener(){

    //recuperation de la ligne selectionnÃ©e
    int rowSelectedList = widget.listeListeTachesAFaire->currentRow();
    QTreeWidgetItem *selectedtask = widget.listeTachesAFaire->currentItem();
    
    if(rowSelectedList==-1) {
       // QMessageBox::information(this,"Erreur","Aucune liste selectionnee !",0,0,0);
    }
    else{
        Task* task;
        
        if(selectedtask==NULL) {
            QMessageBox::information(this,"Erreur","Aucune tache selectionnee !",0,0,0);
        }
        else{   
            QTableWidgetItem* itemNomListe = widget.listeListeTachesAFaire->item(rowSelectedList,0);

            string nomList(itemNomListe->text().toStdString());
            string nomTache(selectedtask->text(0).toStdString());

            ListOfTask *currentListOfTask = NULL;
            std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksLists();
            std::list<ListOfTask*>::iterator it = listListTask.begin();
            std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
            for(;it!=itEnd;++it) {
                ListOfTask* gr = *it;
                if(gr->getName()==nomList) {
                    currentListOfTask = gr;                   
                    break;
                }
            }
            list<Task*> top = currentListOfTask->getTasks();
            task = recTaskFinder(top,nomTache);
            addTaskDialog *modifyTask = new addTaskDialog(this, task, currentListOfTask->getDate());
            modifyTask->setVisible(true);
            
 
        }
    }
}

//Mets à jour la liste des taches en fonction de la liste selectionne
void accueil::updateViewTasksList() {
    
    int nbTasks = widget.listeTachesAFaire->topLevelItemCount();
    
    for (int i=0; i<nbTasks;++i)
    {   
        QTreeWidgetItem *tmpItem = widget.listeTachesAFaire->takeTopLevelItem(0);
        delete tmpItem;
    }
    
    int nbList = utilisateur.GetListOfTasksLists().size();
    int rowSelected = widget.listeListeTachesAFaire->currentRow();
    
    if(nbList!=0) {
        if(rowSelected==-1) {
            QMessageBox::information(this,"Erreur","Aucune liste selectionnee !",0,0,0);
            return;
        }
        else { 
            QTableWidgetItem* itemNom = widget.listeListeTachesAFaire->item(rowSelected,0);

            ListOfTask *currentListOfTask = NULL;
            string nomList = itemNom->text().toStdString();    
            std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksLists();

            std::list<ListOfTask*>::iterator it = listListTask.begin();
            std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
            for(;it!=itEnd;++it) {
                ListOfTask* gr = *it;
                if(gr->getName()==nomList) {
                    currentListOfTask = gr;
                    break;
                }
            }  

            list<Task*> listOftasks = currentListOfTask->getTasks();

            for (std::list<Task*>::iterator it = listOftasks.begin(); it != listOftasks.end(); ++it) {
                Task *tmpTask = *it;
                string name = tmpTask->getTitre(); 
                std::ostringstream oss;
                oss << tmpTask->getNumber();
                string num = oss.str();
                string date = tmpTask->getDate().getDate();
                string relat = afficheDateRelative(tmpTask->getRelative());

                QTreeWidgetItem *item = new QTreeWidgetItem;
                 if (tmpTask->getNumber()==0) {
                item->setText(1,"");
                } else {
                    item->setText(1,QString(num.c_str()));
                }
                item->setText(0,QString(name.c_str()));
                if (tmpTask->getDate().getDay()==0 && tmpTask->getRelative()==-1) {
                        item->setText(2,"");
                } else if(tmpTask->getRelative()!=-1) {
                    item->setText(2,QString(relat.c_str()));
                } else if(tmpTask->getDate().getDay()!=0) {
                    item->setText(2,QString(date.c_str()));
                }
                if(!tmpTask->isChecked()) {
                    item->setCheckState(3,Qt::Unchecked);
                } else {
                    item->setCheckState(3,Qt::Checked);
                }
                widget.listeTachesAFaire->addTopLevelItem(item);               

                list<Task*> listOfunderTasks = tmpTask->getTasks();

                for (std::list<Task*>::iterator its = listOfunderTasks.begin(); its != listOfunderTasks.end(); ++its) {

                    Task *tmpTask2 = *its;

                    string name = tmpTask2->getTitre(); 
                    std::ostringstream oss;
                    oss << tmpTask2->getNumber();
                    string num = oss.str();
                    string date = tmpTask2->getDate().getDate();
                    string relative = afficheDateRelative(tmpTask2->getRelative());

                    QTreeWidgetItem *item2 = new QTreeWidgetItem;
                    if (tmpTask2->getNumber()==0) {
                    item2->setText(1,"");
                    } else {
                        item2->setText(1,QString(num.c_str()));
                    }
                    item2->setText(0,QString(name.c_str()));
                    if (tmpTask2->getDate().getDay()==0 && tmpTask2->getRelative()==-1) {
                        item2->setText(2,"");
                    } else if(tmpTask2->getRelative()!=-1) {
                        item2->setText(2,QString(relative.c_str()));
                    } else if(tmpTask2->getDate().getDay()!=0) {
                        item2->setText(2,QString(date.c_str()));
                    }
                    if(!tmpTask2->isChecked()) {
                    item2->setCheckState(3,Qt::Unchecked);
                    } else {
                        item2->setCheckState(3,Qt::Checked);
                    }

                    item->addChild(item2);

                }
                item->setExpanded(true);
                widget.listeTachesAFaire->resizeColumnToContents(0);
            }
        }
    }
}

void accueil::afficherTasksListener() {
    
    int nbTasks = widget.listeTachesAFaire->topLevelItemCount();
    
    for (int i=0; i<nbTasks;++i)
    {   
        QTreeWidgetItem *tmpItem = widget.listeTachesAFaire->takeTopLevelItem(0);
        delete tmpItem;
    }
    
    int rowSelected = widget.listeListeTachesAFaire->currentRow();
    if(rowSelected!=-1) {
        updateViewTasksList();
    }
}

void accueil::buttonsListListener(){
    int rowSelectedList = widget.listeListeTachesAFaire->currentRow();
    if(rowSelectedList == -1){
        widget.boutonSupprimerListe->setDisabled(true);
        widget.boutonModifierListe->setDisabled(true);
        widget.boutonCreerTache->setDisabled(true); 
    }else{
        widget.boutonCreerTache->setText("Ajouter une tâche");
        widget.boutonSupprimerListe->setDisabled(false);
        widget.boutonModifierListe->setDisabled(false);
        widget.boutonCreerTache->setDisabled(false);
    }
}


void accueil::buttonsTaskListener(){
    QTreeWidgetItem *selectedtask = widget.listeTachesAFaire->currentItem();
    if(selectedtask == NULL){
        widget.boutonSupprimerTache->setDisabled(true);
        widget.boutonModifierTache->setDisabled(true);
    }else{       
        widget.boutonCreerTache->setText("Ajouter une sous-tache");
        widget.boutonSupprimerTache->setDisabled(false);
        widget.boutonModifierTache->setDisabled(false);
    }
    
}

void accueil::listListTacheListener(){

    int nbListe = widget.listeListeTachesAFaire->rowCount();
    
    for (int i=nbListe-1; i>-1; i--)
    {     
        widget.listeListeTachesAFaire->removeRow(i);
    }

    QDate date = widget.calendrier->selectedDate();
    std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksLists();
    std::list<ListOfTask*>::iterator it = listListTask.begin();
    std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
    for(;it!=itEnd;++it) {
        ListOfTask* gr = *it;
        if(QString::compare(date.toString("d/M/yyyy"),QString(gr->getDate().getDate().c_str()))==0){
            
            QTableWidgetItem* itemName = new QTableWidgetItem;
            itemName->setText(QString(gr->getName().c_str()));
            
            QTableWidgetItem* itemDate = new QTableWidgetItem;
            itemDate->setText(QString(gr->getDate().getDate().c_str()));
            
            int currentLigne = widget.listeListeTachesAFaire->rowCount();
            widget.listeListeTachesAFaire->setRowCount(currentLigne+1);
            //On ajoute les donnÃ©es au tableau
            widget.listeListeTachesAFaire->setItem(currentLigne, 0, itemName);
            widget.listeListeTachesAFaire->setItem(currentLigne, 1, itemDate);

            //widget.listeListeTachesAFaire->resizeColumnsToContents();
        }
    }
}

void accueil::addTaskButtonListener() {
    QTreeWidgetItem *selectedtask = widget.listeTachesAFaire->currentItem();
    if(selectedtask!=NULL) {
        if (selectedtask->parent()==NULL) {
            widget.boutonCreerTache->setDisabled(false);
        } else {
            widget.boutonCreerTache->setDisabled(true);
        }
    }
}

/**********************************************************************************************************************/
/*********                                         Onglet Template                                             ********/
/**********************************************************************************************************************/

void accueil::addTemplate(string name) {
    ListOfTask *tmpListTasks = new ListOfTask(name);

    utilisateur.addTemplate(tmpListTasks);
    
    int currentLigne = widget.listeListeTachesAFaire_2->rowCount();

    //On ajoute une ligne au tableau
    widget.listeListeTachesAFaire_2->setRowCount(currentLigne+1);

    //On crÃ©er les diffÃ©rents items que l'on va ajouter au tableau
    QTableWidgetItem* itemName = new QTableWidgetItem;
    itemName->setText(QString(name.c_str()));

    //On ajoute les donnÃ©es au tableau
    widget.listeListeTachesAFaire_2->setItem(currentLigne, 0, itemName);
}

void accueil::addTemplateListener() {
    addTemplateDialog *addListList = new addTemplateDialog(this);
    addListList->setVisible(true);
}

void accueil::modifyTemplate(string name) {
 
    int rowSelected = widget.listeListeTachesAFaire_2->currentRow();

    //On ajoute une ligne au tableau
    QTableWidgetItem* itemName = new QTableWidgetItem;
    itemName->setText(QString(name.c_str()));
    
    //On ajoute les données au tableau
    widget.listeListeTachesAFaire_2->setItem(rowSelected, 0, itemName);
}

void accueil::modifyTemplateListener(){
    
    ListOfTask* list = NULL;
    int rowSelected = widget.listeListeTachesAFaire_2->currentRow();
    if(rowSelected==-1) {
        //QMessageBox::information(this,"Erreur","Aucune liste selectionnee !",0,0,0);
    } else {
        QTableWidgetItem* itemNom = widget.listeListeTachesAFaire_2->item(rowSelected,0);
        string nomList(itemNom->text().toStdString());
        
        std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksTemplates();
        
        std::list<ListOfTask*>::iterator it = listListTask.begin();
        std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
        for(;it!=itEnd;++it) {
            ListOfTask* gr = *it;
            if(gr->getName()==nomList) {
                list = gr;
                break;
            }
        }  
        addTemplateDialog *addListList = new addTemplateDialog(this,list);
        addListList->setVisible(true);
     }
}

void accueil::removeTemplate() {
    //recuperation de la ligne selectionnÃ©e
    int rowSelected = widget.listeListeTachesAFaire_2->currentRow();
    
    if(rowSelected==-1) {
        //QMessageBox::information(this,"Erreur","Aucune liste selectionnee !",0,0,0);
    }
    else { 

        QTableWidgetItem* itemNom = widget.listeListeTachesAFaire_2->item(rowSelected,0);

        string nomList(itemNom->text().toStdString());
        
        std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksTemplates();  
        std::list<ListOfTask*>::iterator it = listListTask.begin();
        std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
        
        switch( QMessageBox::information(this, "Attention", "Etes vous sur de vouloir supprimer la template ainsi que l'integralite de son contenu ?", 
                QMessageBox::Yes | 
                QMessageBox::No) )
        {
          case QMessageBox::Yes:
            for(;it!=itEnd;++it) {
                ListOfTask* gr = *it;
                if(gr->getName()==nomList) {
                    utilisateur.removeList(gr);
                    break;
                }
            }
            widget.listeListeTachesAFaire_2->removeRow(rowSelected);
            break;
          case QMessageBox::No:
            qDebug( "no" );
            break;
          default:
            qDebug( "close" );
            break;
        } 
    }
}

void accueil::addTaskTempListener() {
    addTaskTempDialog *addTask = new addTaskTempDialog(this);
    addTask->setVisible(true);
}

//Ajout d'une tache
void accueil::addTaskTemp(string title, bool isOrdo, int num, bool ech, bool fixe, Date d, int relat) {
    
    //recuperation du no de la liste selectionne
    int listSelected = widget.listeListeTachesAFaire_2->currentRow();
    
    if(listSelected==-1) {
       // QMessageBox::information(this,"Erreur","Aucune liste selectionnee !",0,0,0);
        return;
    }
    else { 
        Task *newTask = new Task(title, isOrdo, num, ech, fixe, d, relat);
        
        QTreeWidgetItem *selectedtask = widget.listeTachesAFaire_2->currentItem();
        QTableWidgetItem* itemNom = widget.listeListeTachesAFaire_2->item(listSelected,0);
        string nomList(itemNom->text().toStdString());
        
        //ajout d'une tache principale
        if (selectedtask==NULL) {

            std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksTemplates();
            std::list<ListOfTask*>::iterator it = listListTask.begin();
            std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
            for(;it!=itEnd;++it) {
                ListOfTask* gr = *it;
                if(gr->getName()==nomList) {
                    gr->addTask(newTask);
                    break;
                }
            }  
            
            string name = newTask->getTitre(); 
            std::ostringstream oss;
            oss << newTask->getNumber();
            string num = oss.str();
            string date = newTask->getDate().getDate();
            string relat = afficheDateRelative(newTask->getRelative());

            QTreeWidgetItem *item = new QTreeWidgetItem;
             if (newTask->getNumber()==0) {
            item->setText(1,"");
            } else {
                item->setText(1,QString(num.c_str()));
            }
            item->setText(0,QString(name.c_str()));
            if (newTask->getDate().getDay()==0 && newTask->getRelative()==-1) {
                    item->setText(2,"");
            } else if(newTask->getRelative()!=-1) {
                item->setText(2,QString(relat.c_str()));
            } else if(newTask->getDate().getDay()!=0) {
                item->setText(2,QString(date.c_str()));
            }  

            widget.listeTachesAFaire_2->addTopLevelItem(item);
            widget.listeTachesAFaire_2->resizeColumnToContents(0);
            
        //ajout d'une sous tache
        } else {
            ListOfTask *currentListOfTask = NULL;
            std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksTemplates();
            std::list<ListOfTask*>::iterator it = listListTask.begin();
            std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
            for(;it!=itEnd;++it) {
                ListOfTask* gr = *it;
                if(gr->getName()==nomList) {
                    currentListOfTask = gr;
                    break;
                }
            } 
    
            list<Task*> top = currentListOfTask->getTasks();

            //On recupere la tache parent :
            Task* parentTask = recTaskFinder(top,selectedtask->text(0).toStdString());

            parentTask->addTask(newTask);
            
            string name = newTask->getTitre(); 
            std::ostringstream oss;
            oss << newTask->getNumber();
            string num = oss.str();
            string date = newTask->getDate().getDate();
            string relative = afficheDateRelative(newTask->getRelative());

            QTreeWidgetItem *item2 = new QTreeWidgetItem;
            if (newTask->getNumber()==0) {
            item2->setText(1,"");
            } else {
                item2->setText(1,QString(num.c_str()));
            }
            item2->setText(0,QString(name.c_str()));
            if (newTask->getDate().getDay()==0 && newTask->getRelative()==-1) {
                item2->setText(2,"");
            } else if(newTask->getRelative()!=-1) {
                item2->setText(2,QString(relative.c_str()));
            } else if(newTask->getDate().getDay()!=0) {
                item2->setText(2,QString(date.c_str()));
            }
            
            selectedtask->addChild(item2);
            selectedtask->setExpanded(true);
            widget.listeTachesAFaire_2->resizeColumnToContents(0);
        }
    }
}

void accueil::afficherTasksTempListener() {
    
    int nbTasks = widget.listeTachesAFaire_2->topLevelItemCount();
    
    for (int i=0; i<nbTasks;++i)
    {   
        QTreeWidgetItem *tmpItem = widget.listeTachesAFaire_2->takeTopLevelItem(0);
        delete tmpItem;
    }
    
    int rowSelected = widget.listeListeTachesAFaire_2->currentRow();
    if(rowSelected!=-1) {
        updateViewTasksTemp();
    }
}

void accueil::updateViewTasksTemp() {
    
    int nbTasks = widget.listeTachesAFaire_2->topLevelItemCount();
    
    for (int i=0; i<nbTasks;++i)
    {   
        QTreeWidgetItem *tmpItem = widget.listeTachesAFaire_2->takeTopLevelItem(0);
        delete tmpItem;
    }
    
    int nbList = utilisateur.GetListOfTasksTemplates().size();
    int rowSelected = widget.listeListeTachesAFaire_2->currentRow();
    
    if(nbList!=0) {
        if(rowSelected==-1) {
           // QMessageBox::information(this,"Erreur","Aucune liste selectionnee !",0,0,0);
            return;
        }
        else { 
            QTableWidgetItem* itemNom = widget.listeListeTachesAFaire_2->item(rowSelected,0);

            ListOfTask *currentListOfTask = NULL;
            string nomList = itemNom->text().toStdString();    
            std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksTemplates();

            std::list<ListOfTask*>::iterator it = listListTask.begin();
            std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
            for(;it!=itEnd;++it) {
                ListOfTask* gr = *it;
                if(gr->getName()==nomList) {
                    currentListOfTask = gr;
                    break;
                }
            }  

            list<Task*> listOftasks = currentListOfTask->getTasks();

            for (std::list<Task*>::iterator it = listOftasks.begin(); it != listOftasks.end(); ++it) {
                Task *tmpTask = *it;
                string name = tmpTask->getTitre(); 
                std::ostringstream oss;
                oss << tmpTask->getNumber();
                string num = oss.str();
                string date = tmpTask->getDate().getDate();
                string relat = afficheDateRelative(tmpTask->getRelative());

                QTreeWidgetItem *item = new QTreeWidgetItem;
                 if (tmpTask->getNumber()==0) {
                item->setText(1,"");
                } else {
                    item->setText(1,QString(num.c_str()));
                }
                item->setText(0,QString(name.c_str()));
                if (tmpTask->getDate().getDay()==0 && tmpTask->getRelative()==-1) {
                        item->setText(2,"");
                } else if(tmpTask->getRelative()!=-1) {
                    item->setText(2,QString(relat.c_str()));
                } else if(tmpTask->getDate().getDay()!=0) {
                    item->setText(2,QString(date.c_str()));
                }
                
                widget.listeTachesAFaire_2->addTopLevelItem(item);               

                list<Task*> listOfunderTasks = tmpTask->getTasks();

                for (std::list<Task*>::iterator its = listOfunderTasks.begin(); its != listOfunderTasks.end(); ++its) {

                    Task *tmpTask2 = *its;

                    string name = tmpTask2->getTitre(); 
                    std::ostringstream oss;
                    oss << tmpTask2->getNumber();
                    string num = oss.str();
                    string date = tmpTask2->getDate().getDate();
                    string relative = afficheDateRelative(tmpTask2->getRelative());

                    QTreeWidgetItem *item2 = new QTreeWidgetItem;
                    if (tmpTask2->getNumber()==0) {
                    item2->setText(1,"");
                    } else {
                        item2->setText(1,QString(num.c_str()));
                    }
                    item2->setText(0,QString(name.c_str()));
                    if (tmpTask2->getDate().getDay()==0 && tmpTask2->getRelative()==-1) {
                        item2->setText(2,"");
                    } else if(tmpTask2->getRelative()!=-1) {
                        item2->setText(2,QString(relative.c_str()));
                    } else if(tmpTask2->getDate().getDay()!=0) {
                        item2->setText(2,QString(date.c_str()));
                    }

                    item->addChild(item2);

                }
                item->setExpanded(true);
                widget.listeTachesAFaire_2->resizeColumnToContents(0);
            }
        }
    }
}

void accueil::removeTaskTemp() {
   
    int rowSelectedList = widget.listeListeTachesAFaire_2->currentRow();
    QTreeWidgetItem *selectedtask = widget.listeTachesAFaire_2->currentItem();
    
    if(rowSelectedList==-1) {
        QMessageBox::information(this,"Erreur","Aucune liste selectionnee !",0,0,0);
    }
    else{
        Task* task;
        
        if(selectedtask==NULL) {
            QMessageBox::information(this,"Erreur","Aucune tache selectionnee !",0,0,0);
        }
        else{   
            QTableWidgetItem* itemNomListe = widget.listeListeTachesAFaire_2->item(rowSelectedList,0);

            string nomList(itemNomListe->text().toStdString());
            string nomTache(selectedtask->text(0).toStdString());

            ListOfTask *currentListOfTask = NULL;
            std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksTemplates();
            std::list<ListOfTask*>::iterator it = listListTask.begin();
            std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
            for(;it!=itEnd;++it) {
                ListOfTask* gr = *it;
                if(gr->getName()==nomList) {
                    currentListOfTask = gr;
                    break;
                }
            }
            list<Task*> top = currentListOfTask->getTasks();
            task = recTaskFinder(top,nomTache);
            QTreeWidgetItem *parent = selectedtask->parent();
            if (parent==NULL) {
                currentListOfTask->removeTask(task);
               delete selectedtask;
            } else {
                Task *parentTask = recTaskFinder(top,parent->text(0).toStdString());
                parentTask->removeTask(task);
                parent->removeChild(selectedtask);
            }
        }
    }
    widget.listeTachesAFaire_2->resizeColumnToContents(0);
}

void accueil::modifyTaskTemp(string title, int num, Date d, int relat) {
   
    QTreeWidgetItem *selectedtask = widget.listeTachesAFaire_2->currentItem();

    if(num!=0) {
        std::ostringstream oss;
        oss << num;
        string number = oss.str();
        selectedtask->setText(1,QString(number.c_str()));
    } else {
        selectedtask->setText(1,"");
    }
    selectedtask->setText(0,QString(title.c_str()));
    if (d.getDay()==0 && relat==-1) {
        selectedtask->setText(2,"");
    } else if(relat!=-1) {
        string relative = afficheDateRelative(relat);
        selectedtask->setText(2,QString(relative.c_str()));
    } else if(d.getDay()!=0) {
        string date = d.getDate();
        selectedtask->setText(2,QString(date.c_str()));
    }
    widget.listeTachesAFaire_2->resizeColumnToContents(0);
}

void accueil::modifyTaskTempListener(){

    //recuperation de la ligne selectionnÃ©e
    int rowSelectedList = widget.listeListeTachesAFaire_2->currentRow();
    QTreeWidgetItem *selectedtask = widget.listeTachesAFaire_2->currentItem();
    
    if(rowSelectedList==-1) {
        QMessageBox::information(this,"Erreur","Aucune liste selectionnee !",0,0,0);
    }
    else{
        Task* task;
        
        if(selectedtask==NULL) {
            QMessageBox::information(this,"Erreur","Aucune tache selectionnee !",0,0,0);
        }
        else{   
            QTableWidgetItem* itemNomListe = widget.listeListeTachesAFaire_2->item(rowSelectedList,0);

            string nomList(itemNomListe->text().toStdString());
            string nomTache(selectedtask->text(0).toStdString());

            ListOfTask *currentListOfTask = NULL;
            std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksTemplates();
            std::list<ListOfTask*>::iterator it = listListTask.begin();
            std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
            for(;it!=itEnd;++it) {
                ListOfTask* gr = *it;
                if(gr->getName()==nomList) {
                    currentListOfTask = gr;
                    break;
                }
            }
            list<Task*> top = currentListOfTask->getTasks();
            task = recTaskFinder(top,nomTache);
            
            addTaskTempDialog *modifyTask = new addTaskTempDialog(this, task);
            modifyTask->setVisible(true);
 
        }
    }
}

void accueil::buttonsTemplateListener(){
    int rowSelectedList = widget.listeListeTachesAFaire_2->currentRow();
    if(rowSelectedList == -1){
        widget.boutonSupprimerListe_2->setDisabled(true);
        widget.boutonModifierListe_2->setDisabled(true);
        widget.boutonCreerTache_2->setDisabled(true); 
        widget.boutonUtiliser->setDisabled(true); 
    }else{
        widget.boutonCreerTache_2->setText("Ajouter une tache");
        widget.boutonSupprimerListe_2->setDisabled(false);
        widget.boutonModifierListe_2->setDisabled(false);
        widget.boutonCreerTache_2->setDisabled(false);
        widget.boutonUtiliser->setDisabled(false);
    }
}


void accueil::buttonsTaskTempListener(){
    QTreeWidgetItem *selectedtask = widget.listeTachesAFaire_2->currentItem();
    if(selectedtask == NULL){
        widget.boutonSupprimerTache_2->setDisabled(true);
        widget.boutonModifierTache_2->setDisabled(true);
    }else{
        widget.boutonCreerTache_2->setText("Ajouter une sous-tache");
        widget.boutonSupprimerTache_2->setDisabled(false);
        widget.boutonModifierTache_2->setDisabled(false);
    }
    
}

void accueil::listeTacheAFaireListener(){
    //QTreeWidgetItem *item = new QTreeWidgetItem;
    widget.listeTachesAFaire->reset();
    widget.boutonSupprimerTache->setDisabled(true);
    widget.boutonModifierTache->setDisabled(true);
    widget.boutonCreerTache->setDisabled(false);
    widget.boutonCreerTache->setText("Ajouter une tache");
    //item->setExpanded(true);
    updateViewTasksList();
    
}

void accueil::tempTacheAFaireListener(){
    //QTreeWidgetItem *item = new QTreeWidgetItem;
    widget.listeTachesAFaire_2->reset();
    widget.boutonSupprimerTache_2->setDisabled(true);
    widget.boutonModifierTache_2->setDisabled(true);
    widget.boutonCreerTache_2->setDisabled(false);
    widget.boutonCreerTache_2->setText("Ajouter une tache");
    //item->setExpanded(true);
    updateViewTasksTemp();
    
}

void accueil::addTaskTempButtonListener() {
    QTreeWidgetItem *selectedtask = widget.listeTachesAFaire_2->currentItem();
    if(selectedtask!=NULL) {
        if (selectedtask->parent()==NULL) {
            widget.boutonCreerTache_2->setDisabled(false);
        } else {
            widget.boutonCreerTache_2->setDisabled(true);
        }
    }
}

void accueil::utiliserTemplate() {
    int rowSelectedList = widget.listeListeTachesAFaire_2->currentRow();
    QTableWidgetItem* itemNomListe = widget.listeListeTachesAFaire_2->item(rowSelectedList,0);
    string nomList(itemNomListe->text().toStdString());
    widget.Tab->setCurrentIndex(0);
    //widget.centralwidget->setEnabled(false);
    addListDialog *addListList = new addListDialog(this,utilisateur,nomList);
    addListList->setVisible(true);
}

void accueil::afficherListesListener(){
    int nbListe = widget.listeListeTachesAFaire->rowCount();
    
    for (int i=nbListe-1; i>-1; i--)
    {     
        widget.listeListeTachesAFaire->removeRow(i);
    }

    
    std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksLists();
    std::list<ListOfTask*>::iterator it = listListTask.begin();
    std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
    for(;it!=itEnd;++it) {
        ListOfTask* gr = *it;
        
            
        QTableWidgetItem* itemName = new QTableWidgetItem;
        itemName->setText(QString(gr->getName().c_str()));

        QTableWidgetItem* itemDate = new QTableWidgetItem;
        itemDate->setText(QString(gr->getDate().getDate().c_str()));

        int currentLigne = widget.listeListeTachesAFaire->rowCount();
        widget.listeListeTachesAFaire->setRowCount(currentLigne+1);
        //On ajoute les donnÃ©es au tableau
        widget.listeListeTachesAFaire->setItem(currentLigne, 0, itemName);
        widget.listeListeTachesAFaire->setItem(currentLigne, 1, itemDate);

        //widget.listeListeTachesAFaire->resizeColumnsToContents();
        
    }
    
}

/**********************************************************************************************************************/
/*********                                                 XML                                                 ********/
/**********************************************************************************************************************/

void accueil::writeDom() {
    
    QDomDocument dom;
    QFile doc_xml("listes.xml");
    doc_xml.open(QIODevice::ReadOnly);
    dom.setContent(&doc_xml);
    
    //racine du document (listes)
    QDomElement docElem = dom.documentElement();
    
    //parcours des listes de l'utilisateur
    std::list<ListOfTask*> listListTask = utilisateur.GetListOfTasksLists();
    std::list<ListOfTask*>::iterator it = listListTask.begin();
    std::list<ListOfTask*>::const_iterator itEnd = listListTask.end();
    for(;it!=itEnd;++it) {
        ListOfTask* gr = *it;
        QDomElement liste = dom.createElement("liste"); // On créé un QDomElement qui a comme nom de balise "liste".
        liste.setAttribute("nom", QString(gr->getName().c_str())); 
        liste.setAttribute("date", QString(gr->getDate().getDate().c_str())); 
        docElem.appendChild(liste);// On ajoute liste dans la balise listes
        
        //parcours des taches de la liste
        std::list<Task*> listTask = gr->getTasks();
        std::list<Task*>::iterator it = listTask.begin();
        std::list<Task*>::const_iterator itEnd = listTask.end();
        for(;it!=itEnd;++it){
            Task* t = *it;
            QDomElement tache = dom.createElement("tache"); // On créé un QDomElement qui a comme nom de balise "tache".
            tache.setAttribute("nom", QString(t->getTitre().c_str())); 
            tache.setAttribute("isOrdo",boolToString(t->isOrdo()));
            std::ostringstream oss;
            oss << t->getNumber();
            std::string numero = oss.str();
            tache.setAttribute("numero",QString(numero.c_str()));
            tache.setAttribute("isEcheance",boolToString(t->isEcheance()));
            tache.setAttribute("fixe",boolToString(t->isFixe()));
            if(!t->getDate().getDay()==0) {
                tache.setAttribute("date",QString(t->getDate().getDate().c_str()));
            }
            std::ostringstream os;
            os << t->getRelative();
            std::string nume = os.str();
            tache.setAttribute("relative", QString(nume.c_str()));
            tache.setAttribute("checked",boolToString(t->isChecked()));

            
            
            liste.appendChild(recTaskDom(dom, tache, t->getTasks()));// On ajoute tache dans la balise listes
        }
    }   
    //Ecriture dans le fichier XML
    QString write = dom.toString();
    QFile fichier("listes.xml");
    fichier.open(QIODevice::WriteOnly);
    QTextStream stream(&fichier);
    stream << write; // On utilise l'opÃ©rateur << pour Ã©crire write_doc dans le document XML.
    fichier.close();
    
    QDomDocument dom2;
    QFile doc_xml2("templates.xml");
    doc_xml2.open(QIODevice::ReadOnly);
    dom2.setContent(&doc_xml2);
    
    //racine du document (templates)
    QDomElement docElem2 = dom2.documentElement();
    
    //parcours des listes de l'utilisateur
    std::list<ListOfTask*> templateListTask = utilisateur.GetListOfTasksTemplates();
    std::list<ListOfTask*>::iterator it2 = templateListTask.begin();
    std::list<ListOfTask*>::const_iterator itEnd2 = templateListTask.end();
    for(;it2!=itEnd2;++it2) {
        ListOfTask* gr = *it2;
        QDomElement temp = dom.createElement("template"); // On créé un QDomElement qui a comme nom de balise "liste".
        temp.setAttribute("nom", QString(gr->getName().c_str())); 
        docElem2.appendChild(temp);// On ajoute liste dans la balise listes
        
        //parcours des taches de la liste
        std::list<Task*> listTask = gr->getTasks();
        std::list<Task*>::iterator it = listTask.begin();
        std::list<Task*>::const_iterator itEnd = listTask.end();
        for(;it!=itEnd;++it){
            Task* t = *it;
            QDomElement tache = dom2.createElement("tache"); // On créé un QDomElement qui a comme nom de balise "tache".
            tache.setAttribute("nom", QString(t->getTitre().c_str())); 
            tache.setAttribute("isOrdo",boolToString(t->isOrdo()));
            std::ostringstream oss;
            oss << t->getNumber();
            std::string numero = oss.str();
            tache.setAttribute("numero",QString(numero.c_str()));
            tache.setAttribute("isEcheance",boolToString(t->isEcheance()));
            tache.setAttribute("fixe",boolToString(t->isFixe()));
            if(!t->getDate().getDay()==0) {
                tache.setAttribute("date",QString(t->getDate().getDate().c_str()));
            }
            std::ostringstream os;
            os << t->getRelative();
            std::string nume = os.str();
            tache.setAttribute("relative", QString(nume.c_str()));
            
            
            temp.appendChild(recTaskDom(dom2, tache, t->getTasks()));// On ajoute tache dans la balise listes
        }
    }   
    //Ecriture dans le fichier XML
    write = dom2.toString();
    QFile fichier2("templates.xml");
    fichier2.open(QIODevice::WriteOnly);
    QTextStream stream2(&fichier2);
    stream2 << write; // On utilise l'opÃ©rateur << pour Ã©crire write_doc dans le document XML.
    fichier2.close();
}

QDomElement accueil::recTaskDom(QDomDocument dom, QDomElement item, list<Task*> listOfunderTasks) {
    
    for (std::list<Task*>::iterator its = listOfunderTasks.begin(); its != listOfunderTasks.end(); ++its) {

        Task *t = *its;

        QDomElement tache2 = dom.createElement("tache"); // On créé un QDomElement qui a comme nom de balise "tache".
        tache2.setAttribute("nom", QString(t->getTitre().c_str())); 
        tache2.setAttribute("isOrdo",boolToString(t->isOrdo()));
        std::ostringstream oss;
        oss << t->getNumber();
        std::string numero = oss.str();
        tache2.setAttribute("numero",QString(numero.c_str()));
        tache2.setAttribute("isEcheance",boolToString(t->isEcheance()));
        tache2.setAttribute("fixe",boolToString(t->isFixe()));
        if(!t->getDate().getDay()==0) {
            tache2.setAttribute("date",QString(t->getDate().getDate().c_str()));
        }
        std::ostringstream os;
        os << t->getRelative();
        std::string nume = os.str();
        tache2.setAttribute("relative", QString(nume.c_str()));
        tache2.setAttribute("checked",boolToString(t->isChecked()));

        item.appendChild(recTaskDom(dom, tache2, t->getTasks())); 
    }
    return item;
}

void accueil::readDom() {

     QDomDocument dom;
     QFile file("listes.xml");
     file.open(QIODevice::ReadOnly);
     dom.setContent(&file);
     file.close();
     
     QDomElement docElem = dom.documentElement();
     QDomNode listeCourante = docElem.firstChild();
     while(!listeCourante.isNull()) 
     {
        QDomElement e = listeCourante.toElement(); 
        QString nom = e.attribute("nom");
        QString date= e.attribute("date");

        //Récupération du jour, du mois et de l'année pour contruire la liste
        string ladate(date.toStdString());
        vector<string> VecStr;
        split(VecStr, ladate, '/');
        string jour = VecStr[0];
        string mois = VecStr[1];
        string annee = VecStr[2];

        ListOfTask *list = new ListOfTask(nom.toStdString(),Date(atoi(jour.c_str()),atoi(mois.c_str()),atoi(annee.c_str())));
        utilisateur.addList(list);

        QDomNode tacheCourante = listeCourante.firstChild();
        while(!tacheCourante.isNull()) {
            QDomElement t = tacheCourante.toElement();
            
            QString nomTache = t.attribute("nom");
            QString ordo = t.attribute("isOrdo");
            QString numero = t.attribute("numero");
            QString echeance = t.attribute("isEcheance");
            QString fixe = t.attribute("fixe");
            QString relat = t.attribute("relative");
            QString checked = t.attribute("checked");
            Date dateTask;
            QString dateTache;
            if (t.hasAttribute("date")) {
                dateTache = t.attribute("date");
                string ladate(dateTache.toStdString());
                vector<string> VecStr;
                split(VecStr, ladate, '/');
                string jour = VecStr[0];
                string mois = VecStr[1];
                string annee = VecStr[2];
                dateTask = Date(atoi(jour.c_str()),atoi(mois.c_str()),atoi(annee.c_str()));
            } else {
                dateTask = Date();
            }
            
            Task *task = new Task(nomTache.toStdString(),stringToBool(ordo.toStdString()),atoi(numero.toStdString().c_str()),stringToBool(echeance.toStdString()),stringToBool(fixe.toStdString()),dateTask, atoi(relat.toStdString().c_str()));
            task->setChecked(stringToBool(checked.toStdString()));
            list->addTask(task);
            
            QDomNode sousTacheCourante = tacheCourante.firstChild();
            while(!sousTacheCourante.isNull()) {
                QDomElement s = sousTacheCourante.toElement();
                QString nomSsTache = s.attribute("nom");
                QString ordoSsTache = s.attribute("isOrdo");
                QString numeroSsTache = s.attribute("numero");
                QString echeanceSsTache = s.attribute("isEcheance");
                QString fixeSsTache = s.attribute("fixe");
                QString relatSsTache = s.attribute("relative");
                QString checkedSsTache = s.attribute("checked");
                Date dateSsTask;
                QString dateSsTache;
                if (s.hasAttribute("date")) {
                    dateSsTache = s.attribute("date");
                    string ladate(dateSsTache.toStdString());
                    vector<string> VecStr;
                    split(VecStr, ladate, '/');
                    string jourSsTache = VecStr[0];
                    string moisSsTache = VecStr[1];
                    string anneeSsTache = VecStr[2];
                    dateSsTask = Date(atoi(jourSsTache.c_str()),atoi(moisSsTache.c_str()),atoi(anneeSsTache.c_str()));
                } else {
                    dateSsTask = Date();
                }

                Task *ssTask = new Task(nomSsTache.toStdString(),stringToBool(ordoSsTache.toStdString()),atoi(numeroSsTache.toStdString().c_str()),stringToBool(echeanceSsTache.toStdString()),stringToBool(fixeSsTache.toStdString()),dateSsTask, atoi(relatSsTache.toStdString().c_str()));
                task->addTask(ssTask);
                ssTask->setChecked(stringToBool(checkedSsTache.toStdString()));
                sousTacheCourante = sousTacheCourante.nextSibling();
                }
            
            tacheCourante = tacheCourante.nextSibling();
        }

        int currentLigne = widget.listeListeTachesAFaire->rowCount();

        //On ajoute une ligne au tableau
        widget.listeListeTachesAFaire->setRowCount(currentLigne+1);
        
        QTableWidgetItem* itemName = new QTableWidgetItem;
        itemName->setText(nom);

        QTableWidgetItem* itemDate = new QTableWidgetItem;
        itemDate->setText(date);

        //On ajoute les données au tableau
        widget.listeListeTachesAFaire->setItem(currentLigne, 0, itemName);
        widget.listeListeTachesAFaire->setItem(currentLigne, 1, itemDate);

        listeCourante = listeCourante.nextSibling();
     }
     
     QDomDocument dom2;
     QFile file2("templates.xml");
     file2.open(QIODevice::ReadOnly);
     dom2.setContent(&file2);
     file2.close();
     
     QDomElement docElem2 = dom2.documentElement();
     QDomNode listeCourante2 = docElem2.firstChild();
     while(!listeCourante2.isNull()) 
     {
        QDomElement e2 = listeCourante2.toElement(); 
        QString nom2 = e2.attribute("nom");

        ListOfTask *temp = new ListOfTask(nom2.toStdString());
        utilisateur.addTemplate(temp);

        QDomNode tacheCourante2 = listeCourante2.firstChild();
        while(!tacheCourante2.isNull()) {
            QDomElement t2 = tacheCourante2.toElement();
            
            QString nomTache = t2.attribute("nom");
            QString ordo = t2.attribute("isOrdo");
            QString numero = t2.attribute("numero");
            QString echeance = t2.attribute("isEcheance");
            QString fixe = t2.attribute("fixe");
            QString relat = t2.attribute("relative");
            QString checked = t2.attribute("checked");
            Date dateTask;
            QString dateTache;
            if (t2.hasAttribute("date")) {
                dateTache = t2.attribute("date");
                string ladate(dateTache.toStdString());
                vector<string> VecStr;
                split(VecStr, ladate, '/');
                string jour = VecStr[0];
                string mois = VecStr[1];
                string annee = VecStr[2];
                dateTask = Date(atoi(jour.c_str()),atoi(mois.c_str()),atoi(annee.c_str()));
            } else {
                dateTask = Date();
            }
            
            Task *task = new Task(nomTache.toStdString(),stringToBool(ordo.toStdString()),atoi(numero.toStdString().c_str()),stringToBool(echeance.toStdString()),stringToBool(fixe.toStdString()),dateTask, atoi(relat.toStdString().c_str()));
            task->setChecked(stringToBool(checked.toStdString()));
            temp->addTask(task);
            
            QDomNode sousTacheCourante = tacheCourante2.firstChild();
            while(!sousTacheCourante.isNull()) {
                QDomElement s = sousTacheCourante.toElement();
                QString nomSsTache = s.attribute("nom");
                QString ordoSsTache = s.attribute("isOrdo");
                QString numeroSsTache = s.attribute("numero");
                QString echeanceSsTache = s.attribute("isEcheance");
                QString fixeSsTache = s.attribute("fixe");
                QString relatSsTache = s.attribute("relative");
                QString checkedSsTache = s.attribute("checked");
                Date dateSsTask;
                QString dateSsTache;
                if (s.hasAttribute("date")) {
                    dateSsTache = s.attribute("date");
                    string ladate(dateSsTache.toStdString());
                    vector<string> VecStr;
                    split(VecStr, ladate, '/');
                    string jourSsTache = VecStr[0];
                    string moisSsTache = VecStr[1];
                    string anneeSsTache = VecStr[2];
                    dateSsTask = Date(atoi(jourSsTache.c_str()),atoi(moisSsTache.c_str()),atoi(anneeSsTache.c_str()));
                } else {
                    dateSsTask = Date();
                }

                Task *ssTask = new Task(nomSsTache.toStdString(),stringToBool(ordoSsTache.toStdString()),atoi(numeroSsTache.toStdString().c_str()),stringToBool(echeanceSsTache.toStdString()),stringToBool(fixeSsTache.toStdString()),dateSsTask, atoi(relatSsTache.toStdString().c_str()));
                task->addTask(ssTask);
                ssTask->setChecked(stringToBool(checkedSsTache.toStdString()));
                sousTacheCourante = sousTacheCourante.nextSibling();
                }
            
            tacheCourante2 = tacheCourante2.nextSibling();
        }

        int currentLigne = widget.listeListeTachesAFaire_2->rowCount();

        //On ajoute une ligne au tableau
        widget.listeListeTachesAFaire_2->setRowCount(currentLigne+1);
        
        QTableWidgetItem* itemName = new QTableWidgetItem;
        itemName->setText(nom2);

        //On ajoute les données au tableau
        widget.listeListeTachesAFaire_2->setItem(currentLigne, 0, itemName);

        listeCourante2 = listeCourante2.nextSibling();
     }
}

void accueil::clearDom() {
    
    QDomDocument dom;   
    QFile doc_xml("listes.xml");
    doc_xml.open(QIODevice::ReadWrite);
    dom.setContent(&doc_xml);
      
    QDomElement docElem = dom.documentElement();
              
    QDomNode n = docElem.firstChild();
    while(!n.isNull()) {
        QDomNode copy = n.nextSibling();
        QDomElement e = n.toElement();

        if(!e.isNull()) {
                docElem.removeChild(n);
        }
        n = copy;
    }
    QString write_doc = dom.toString();

    QTextStream stream(&doc_xml);
    doc_xml.close();
    
    doc_xml.open(QIODevice::WriteOnly|QFile::Truncate);
    stream << write_doc;
    doc_xml.close();
    
    QDomDocument dom2;   
    QFile doc_xml2("templates.xml");
    doc_xml2.open(QIODevice::ReadWrite);
    dom2.setContent(&doc_xml2);
      
    QDomElement docElem2 = dom2.documentElement();
              
    QDomNode n2 = docElem2.firstChild();
    while(!n2.isNull()) {
        QDomNode copy = n2.nextSibling();
        QDomElement e = n2.toElement();

        if(!e.isNull()) {
                docElem2.removeChild(n2);
        }
        n2 = copy;
    }
    QString write_doc2 = dom2.toString();

    QTextStream stream2(&doc_xml2);
    doc_xml2.close();
    
    doc_xml2.open(QIODevice::WriteOnly|QFile::Truncate);
    stream2 << write_doc2;
    doc_xml2.close();
}

/**********************************************************************************************************************/
/*********                                         Fonctions utiles                                            ********/
/**********************************************************************************************************************/

void accueil::split(vector<string>& vecteur, string chaine, char separateur)
{
	vecteur.clear();

	string::size_type stTemp = chaine.find(separateur);
	
	while(stTemp != string::npos)
	{
		vecteur.push_back(chaine.substr(0, stTemp));
		chaine = chaine.substr(stTemp + 1);
		stTemp = chaine.find(separateur);
	}
	
	vecteur.push_back(chaine);
}

QString accueil::boolToString(bool b) {
    QString result;
    if (b)
        result = "true";
    else
        result = "false";
    return result;
}

bool accueil::stringToBool(string str) {
    std::transform(str.begin(), str.end(), str.begin(), ::tolower);
    std::istringstream is(str);
    bool b;
    is >> std::boolalpha >> b;
    return b;
}

string accueil::afficheDateRelative(int index) {
    string s;
    switch(index) {
        case 0 : 
            s="1 jour avant";
            break;
        case 1 :
            s="2 jours avant";
            break;
        case 2 :
            s="3 jours avant";
            break;
        case 3 :
            s="4 jours avant";
            break;
        case 4 :
            s="5 jours avant";
            break; 
        case 5 :
            s="6 jours avant";
            break;
        case 6 :
            s="1 semaine avant";
            break;
        case 7 :
            s="2 semaines avant";
            break;
        case 8 :
            s="3 semaines avant";
            break;
        case 9 :
            s="1 mois avant";
            break;
        case 10 :
            s="2 mois avant";
            break;
        case 11 :
            s="3 mois avant";
            break;
        case -1 :
            s="";
            break;
        default :
            s="";
            break;
    }
    return s;
}